import { showToast } from "@/utils/tools";
import { defineStore } from "pinia";
import { ref } from 'vue';

import { initQuestionnaireListPagination } from '@/static/constants/questionnaire-constant'
import { requestGetQuestionnaireList, reqMarkAllQuestionnaireRead } from "@/api/api-questionnaire-list";
import { reqDeleteReceivedQuestionnaire, reqEditQuestionnaire } from "@/api/api-questionnaire";
import dayjs from "dayjs";

export const useQuestionnaireList = defineStore("questionnaireList", () => {

  // TEST
  // 问卷模板列表
  const questionnaireTemplateList = ref<Array<Questionnaire>>([])

  /** 创建的问卷 */
  const createdQuestionnaireList = ref<Array<Questionnaire>>([])

  /** 收到的问卷 */
  const receivedQuestionnaireList = ref<Array<Questionnaire>>([])

  /** 已删除的问卷 */
  const deletedQuestionnaireList = ref<Array<Questionnaire>>([])

  /** 已过期的问卷 */
  const expiredQuestionnaireList = ref<Array<Questionnaire>>([])

  // #region 问卷列表数据操作相关

  /** 问卷列表数据和类型的映射关系 */
  const questionnaireListInfo: QuestionnaireListInfo = {
    /** 已创建的问卷 */
    'created': {
      list: createdQuestionnaireList,
      pagination: initQuestionnaireListPagination,
      lastGetListFinished: true,
      kind: '1',
    },
    /** 收到的问卷 */
    'received': {
      list: receivedQuestionnaireList,
      pagination: initQuestionnaireListPagination,
      lastGetListFinished: true,
      kind: '4',
    },
    /** 已删除的问卷 */
    'deleted': {
      list: deletedQuestionnaireList,
      pagination: initQuestionnaireListPagination,
      lastGetListFinished: true,
      kind: '2',
    },
    /** 已过期的问卷 */
    'expired': {
      list: expiredQuestionnaireList,
      pagination: initQuestionnaireListPagination,
      lastGetListFinished: true,
      kind: '3',
    },
    /** 问卷模板 */
    'template': {
      list: questionnaireTemplateList,
      pagination: initQuestionnaireListPagination,
      lastGetListFinished: true,
      kind: '5',
    },
  }

  /**
   * 重置问卷数据
   * @param type 问卷类型 created | received | deleted | expired | all，默认为all
   */
  const resetQuestionnaireList = (type: QuestionnaireCategory | 'all' = 'all') => {
    switch (type) {
      case 'all':
        // 遍历问卷列表数据和类型的映射关系，重置问卷列表数据
        Object.keys(questionnaireListInfo).forEach((key) => {
          // XXX 这里对key的类型推断有问题，所以只好进行类型断言
          questionnaireListInfo[key as QuestionnaireCategory].list.value = []
          questionnaireListInfo[key as QuestionnaireCategory].pagination = initQuestionnaireListPagination
        })
        break
      default:
        // 重置指定类型的问卷列表数据
        questionnaireListInfo[type].list.value = []
        questionnaireListInfo[type].pagination = initQuestionnaireListPagination
        break
    }
  }

  /**
   * 判断能否执行获取问卷列表操作
   * @param type 问卷类型 created | received | deleted | expired | template，默认为created
   */
  const canGetQuestionnaireList = (type: QuestionnaireCategory = 'created') => {
    // 如果上次获取创建的问卷未执行完成，不执行
    if (!questionnaireListInfo[type].lastGetListFinished) {
      console.log(type, '上次获取创建的问卷未执行完成')
      return false
    }

    // 解构分页信息
    const { currentPage, totalPage } = questionnaireListInfo[type].pagination
    // 如果分页数据中的current不为0，判断是否已取得所有数据
    if (currentPage !== 0) {
      if (currentPage >= totalPage) {
        return false
      }
    }
    // 设置上次获取创建的问卷未执行完成
    questionnaireListInfo[type].lastGetListFinished = false
    return true
  }


  /**
   * 获取问卷，新的问卷内容会追加到原有问卷列表后面
   * @param type 问卷类型 created | received | deleted | expired | template，默认为created
   */
  const getQuestionnaireList = async (type: QuestionnaireCategory = 'created') => {

    // 如果不能获取问卷列表，不执行
    if (!canGetQuestionnaireList(type)) return

    const { currentPage, pageSize } = questionnaireListInfo[type].pagination

    try {
      // 请求获取创建的问卷
      const res: any = await requestGetQuestionnaireList(
        (currentPage + 1).toString(),
        pageSize.toString(),
        questionnaireListInfo[type].kind
      )
      console.log(type, 'question list res', res)

      // 如果是收到的问卷，则需要判断是否有未读的问卷
      if (type === 'received') {
        unreadQuestionnaireCount.value = res.data.data.unreadQuestionnaireCount
      }

      // 将结果添加到对应的问卷列表
      questionnaireListInfo[type].list.value.push(
        ...res.data.data.list.map((item: any) => {
          return {
            // 根据是否是收到的问卷，解析的字段也不同
            // 问卷内容，如果是收到的问卷，需要解析content_json字段
            ...JSON.parse(type === 'received' ? item.content_json : item.content),

            // 问卷创建日期
            createDate: dayjs(item.create_time).format('YYYY-MM-DD'),
            // 问卷id，如果是收到的问卷，需要解析answer_id字段
            id: type === 'received' ? item.answer_id.toString() : item.question_id.toString(),

            // 问卷模板字符串，如果是收到的问卷，需要解析content字段
            template: type === 'received' ? item.content : undefined,
          }
        })
      )

      console.log(type, 'questionnaireList', questionnaireListInfo[type].list.value)

      // 设置对应的问卷列表的分页信息
      questionnaireListInfo[type].pagination = {
        currentPage: currentPage + 1,
        totalPage: res.data.data.totalPage,
        pageSize: pageSize,
        totalResult: res.data.data.totalResult,
      }
    } catch (err: any) {
      console.error(`获取${type}问卷列表失败`, err)
    }
    // 设置上次获取创建的问卷已执行完成
    questionnaireListInfo[type].lastGetListFinished = true
  }

  /** 从模板创建问卷 */
  const createQuestionnaireByTemplate = (id: string): Questionnaire => {
    // 从模板列表中找到对应的模板
    const index = questionnaireTemplateList.value.findIndex(item => item.id === id)

    // 返回一个新的问卷对象
    return {
      ...JSON.parse(JSON.stringify(questionnaireTemplateList.value[index])),
      id: '',
      createDate: new Date().toISOString().slice(0, 10),
    }
  }

  /**
   * 检索问卷
   * @description 根据问卷id和类型检索问卷
   * @param id 问卷id
   * @param type 问卷类型
   * @returns 问卷
   */
  const searchQuestionnaire = (id: string, type: QuestionnaireCategory = 'created') => {
    switch (type) {
      case 'created':
        return createdQuestionnaireList.value.find(item => item.id === id)
      case 'deleted':
        return deletedQuestionnaireList.value.find(item => item.id === id)
      case 'expired':
        return expiredQuestionnaireList.value.find(item => item.id === id)
      case 'received':
        return receivedQuestionnaireList.value.find(item => item.id === id)
    }
  }

  /**
   * 删除收到的问卷
   * @param id 问卷id
   */
  const deleteReceivedQuestionnaire = async (id: string) => {
    const res: any = await reqDeleteReceivedQuestionnaire(id)
    console.log('delete received questionnaire res', res)
    // 从收到的问卷列表中删除
    receivedQuestionnaireList.value = receivedQuestionnaireList.value.filter(item => item.id !== id)

    if (res.data.code === 200) {
      return true
    } else {
      return false
    }
  }


  /**
  * 复制问卷 以被复制的问卷为模板创建一个新的问卷
  * @param id 问卷id
  * @param type 问卷类型 created | received | deleted | expired，默认为created
  */
  const copyQuestionnaire = async (id: string, type: QuestionnaireCategory = 'created') => {
    // 检索问卷
    const questionnaire = searchQuestionnaire(id, type)
    if (!questionnaire) return

    // 如果是收到的问卷，需要解析template字段
    const template: Questionnaire = type === 'received' ?
      {
        ...JSON.parse(questionnaire.template!),
        id: ''
      } : {
        ...questionnaire,
        id: ''
      }
    console.log('copy questionnaire', template)

    // 如果已经过期，需要重新设置过期时间为10天后
    if (new Date(template.deadline).getTime() < new Date().getTime()) {
      template.deadline = new Date(new Date().getTime() + 10 * 24 * 60 * 60 * 1000).toISOString().slice(0, 10)
    }

    // 向后端请求创建问卷
    try {
      await reqEditQuestionnaire(template)
    } catch {
      showToast('复制失败')
      return
    }
    // // 重新获取已创建的问卷列表
    resetQuestionnaireList('created')
    await getQuestionnaireList('created')
  }


  /**
   * 恢复问卷
   * @description 将问卷从已删除列表中恢复到已创建列表中
   * @param id 问卷id
   */
  const recoverQuestionnaire = (id: string) => {
    const questionnaire = searchQuestionnaire(id, 'deleted')
    console.log('recover questionnaire', questionnaire)
    if (questionnaire) {
      reqEditQuestionnaire(questionnaire)
        .then((res: any) => {
          console.log('recover res', res)
          // 如果成功恢复，重新获取已删除列表
          if (res.data.code === 200) {
            showToast('已恢复', 'success')
            getQuestionnaireList('deleted')
          }
        })
    }
  }

  //#endregion

  //#region 问卷未读相关
  /** 未读问卷数量 */
  const unreadQuestionnaireCount = ref<number>(0)

  /** 标记所有问卷都已读 */
  const markAllQuestionnaireRead = async () => {
    try {
      await reqMarkAllQuestionnaireRead()
      unreadQuestionnaireCount.value = 0
    } catch {
      console.log('标记所有问卷已读失败')
    }
  }

  return {
    questionnaireTemplateList,
    createdQuestionnaireList,
    receivedQuestionnaireList,
    deletedQuestionnaireList,
    expiredQuestionnaireList,

    resetQuestionnaireList,
    getQuestionnaireList,
    createQuestionnaireByTemplate,
    searchQuestionnaire,
    copyQuestionnaire,
    deleteReceivedQuestionnaire,
    recoverQuestionnaire,

    unreadQuestionnaireCount,
    markAllQuestionnaireRead,
  }
})
